1. Field of the Invention (Technical Field)
The present invention relates to processing of graphics and more particularly to a method and apparatus for processing high order graphics languages, such as OpenGL®, for embedded systems, for multiple application tasks, and for partitions.
2. Background Art
Traditionally, applications which involve graphics are restricted by the capabilities of the rendering engine. Typically a single processor is used to execute the application and execute the drivers of the graphics rendering hardware. Applications are then tailored to accommodate the graphics rendering hardware. With the use of larger displays and multiple graphics windows as well as the need for time and space partitioned operating systems, there is a need for more complex tasking and partitioning. The problem is that all of the partitions and tasks eventually funnel back to a single hardware graphics engine which may impose the blocking of functions as rendering occurs. The existing overhead of processing graphics calls to drive the graphics processing unit (GPU) is exacerbated by any blocking in the graphics pipeline. In addition, the costs of developing drivers to keep up with the quickly outdated GPUs have created the need to use commercially available drivers that may not support the operating system of the legacy application.
Presently, a single processor communicating with graphics hardware at a fixed update rate slow enough for the display task to complete or having no fixed update rate is what is traditionally done. Embedded OpenGL® drivers operate in a single partition.
An example of this prior art systems is described in U.S. Pat. No. 6,525,738, entitled Display List Processor for Decoupling Graphics Subsystem Operations From a Host Processor, which teaches a method for a single application task, whereas this method allows for multiple application tasks.
Another prior art device is described in U.S. Pat. No. 6,249,294, entitled 3D Graphics in a Single Logical Screen Display Using Multiple Computer Systems which describes a method that uses a fifo to queue display lists. The present invention buffers by Windows and manages for multiple context/windows. The prior art method is for communication between computers, whereas this method is for a single embedded device.
Other prior art approaches include Microsoft Windows® for personal computers which can support multiple cores (SMP) and render displays using 3D hardware accelerators for graphics. Windows (SMP) allows multiple threads to operate on more than one core. X Windows GUI for Unix supports a client-server over a network method of OpenGL® operation. X Windows allows one computer to act as an OpenGL® client while another computer acts as an OpenGL® server over a network.
This invention is designed to optimize performance for graphics processors using multiple processors. Windows SMP does not allow a single thread such as OpenGL® application linked with a device driver to operate on more than one processor. The X Windows system uses a network style interface that requires decoding and encoding of X Windows system calls into OpenGL® calls. The X Windows system does not have the ability to statically configure the client server between separate processors on a single computer.
The problem has not been addressed by the prior art devices because using three dimensional (3D) hardware graphics accelerators needs a unique solution for real time embedded systems. Only recently has high end graphics capabilities been available in real time systems. Real time systems have typically limited tasking and windowing capabilities. Non real time operating systems do not support fixed update rates. Further, non real time operating systems do much of the windowing without 3D hardware graphics accelerators. Most operations are supported in two-dimensional (2D) only and 3D features are only supported in a single context.
There is a longstanding need to increase graphics performance. The present invention meets this need and provides for multiple application tasks rendered to a hardware graphics processor by using two processors when rendering to single screen. This improves graphics throughput and allows complex tasking/partitioning for application software and allows: any task of any partition to render to any graphics window.